/**
 * Copyright (c) Software Institude of PKU
 * All rights reserved. 
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 */
package edu.pku.sei.modeler.model.uml.BasicInteractions;
// imports:
import org.w3c.dom.Element;

import edu.pku.sei.gefcommon.descriptor.annotation.MethodProperty;
import edu.pku.sei.modeler.model.common.MetaTypedList;
import edu.pku.sei.modeler.model.uml.BasicBehaviors.Behavior;
import edu.pku.sei.modeler.model.uml.Collaborations.CollaborationUse;
import edu.pku.sei.modeler.model.uml.Communications.Reception;
import edu.pku.sei.modeler.model.uml.Dependencies.Substitution;
import edu.pku.sei.modeler.model.uml.Fragments.Gate;
import edu.pku.sei.modeler.model.uml.FundamentalActivities.Action;
import edu.pku.sei.modeler.model.uml.Interfaces.BehavioredClassifier;
import edu.pku.sei.modeler.model.uml.Kernel.Classifier;
import edu.pku.sei.modeler.model.uml.Kernel.Constraint;
import edu.pku.sei.modeler.model.uml.Kernel.ElementImport;
import edu.pku.sei.modeler.model.uml.Kernel.Feature;
import edu.pku.sei.modeler.model.uml.Kernel.Generalization;
import edu.pku.sei.modeler.model.uml.Kernel.NamedElement;
import edu.pku.sei.modeler.model.uml.Kernel.Operation;
import edu.pku.sei.modeler.model.uml.Kernel.PackageImport;
import edu.pku.sei.modeler.model.uml.Kernel.PackageableElement;
import edu.pku.sei.modeler.model.uml.Kernel.Parameter;
import edu.pku.sei.modeler.model.uml.Kernel.Property;
import edu.pku.sei.modeler.model.uml.Kernel.RedefinableElement;
import edu.pku.sei.modeler.model.uml.Kernel.UMLClass;
import edu.pku.sei.modeler.model.uml.UseCases.UseCase;
import edu.pku.sei.modeler.model.xml.XMLUtility;
import edu.pku.sei.modeler.uml.modelHelper.ModelPackage;


/**
 * @generated
 *
 */
public class Interaction extends InteractionFragment implements IInteraction {
	// attributes
	
	
	
	protected boolean isReentrant;
	
	protected boolean isActive;
	
	protected boolean isAbstract;
	
	protected boolean isLeaf;
	
	
	// references
	
	protected MetaTypedList fragment;
	
	protected MetaTypedList lifeline;
	
	protected MetaTypedList message;
	
	protected MetaTypedList formalGate;
	
	protected MetaTypedList action;
	
	
	
	protected MetaTypedList ownedParameter;
	
	protected MetaTypedList redefinedBehavior;
	
	protected MetaTypedList context;
	
	protected MetaTypedList precondition;
	
	protected MetaTypedList postcondition;
	
	protected MetaTypedList ownedAttribute;
	
	protected MetaTypedList nestedClassifier;
	
	protected MetaTypedList ownedOperation;
	
	protected MetaTypedList superClass;
	
	protected MetaTypedList ownedReception;
	
	protected MetaTypedList attribute;
	
	protected MetaTypedList generalization;
	
	protected MetaTypedList inheritedMember;
	
	protected MetaTypedList general;
	
	protected MetaTypedList redefinedClassifier;
	
	protected MetaTypedList feature;
	
	protected MetaTypedList substitutingClassifier;
	
	protected MetaTypedList ownedUseCase;
	
	protected MetaTypedList collaborationUse;
	
	protected MetaTypedList representation;
	
	protected MetaTypedList importedMember;
	
	protected MetaTypedList member;
	
	protected MetaTypedList ownedMember;
	
	protected MetaTypedList packageImport;
	
	protected MetaTypedList elementImport;
	
	protected MetaTypedList ownedRule;
	
	protected MetaTypedList redefinitionContext;
	
	protected MetaTypedList redefinedElement;
	
	// getters & setters for attributes
	
	@MethodProperty(
			id = "INTERACTION_ISREENTRANT",
			catalog = "Model",
			name = ModelPackage.BEHAVIOR_ISREENTRANT,
			setter = "setisReentrant"
			)
	
	public boolean getIsReentrant() {
		return isReentrant;
	}
	public void setIsReentrant(boolean newIsReentrant) {
		boolean oldisReentrant = isReentrant;
		isReentrant = newIsReentrant;
		firePropertyChange(ModelPackage.BEHAVIOR_ISREENTRANT, oldisReentrant, newIsReentrant);
	}
	
	@MethodProperty(
			id = "INTERACTION_ISACTIVE",
			catalog = "Model",
			name = ModelPackage.UMLCLASS_ISACTIVE,
			setter = "setisActive"
			)
	
	public boolean getIsActive() {
		return isActive;
	}
	public void setIsActive(boolean newIsActive) {
		boolean oldisActive = isActive;
		isActive = newIsActive;
		firePropertyChange(ModelPackage.UMLCLASS_ISACTIVE, oldisActive, newIsActive);
	}
	
	@MethodProperty(
			id = "INTERACTION_ISABSTRACT",
			catalog = "Model",
			name = ModelPackage.CLASSIFIER_ISABSTRACT,
			setter = "setisAbstract"
			)
	
	public boolean getIsAbstract() {
		return isAbstract;
	}
	public void setIsAbstract(boolean newIsAbstract) {
		boolean oldisAbstract = isAbstract;
		isAbstract = newIsAbstract;
		firePropertyChange(ModelPackage.CLASSIFIER_ISABSTRACT, oldisAbstract, newIsAbstract);
	}
	
	@MethodProperty(
			id = "INTERACTION_ISLEAF",
			catalog = "Model",
			name = ModelPackage.REDEFINABLEELEMENT_ISLEAF,
			setter = "setisLeaf"
			)
	
	public boolean getIsLeaf() {
		return isLeaf;
	}
	public void setIsLeaf(boolean newIsLeaf) {
		boolean oldisLeaf = isLeaf;
		isLeaf = newIsLeaf;
		firePropertyChange(ModelPackage.REDEFINABLEELEMENT_ISLEAF, oldisLeaf, newIsLeaf);
	}
	
	// getters for references
	
	public MetaTypedList getFragment() {
		if(fragment == null) {
			fragment = new MetaTypedList(InteractionFragment.class, this, ModelPackage.INTERACTION_FRAGMENT);
		}
		return fragment;
	}
	
	public MetaTypedList getLifeline() {
		if(lifeline == null) {
			lifeline = new MetaTypedList(Lifeline.class, this, ModelPackage.INTERACTION_LIFELINE);
		}
		return lifeline;
	}
	
	public MetaTypedList getMessage() {
		if(message == null) {
			message = new MetaTypedList(Message.class, this, ModelPackage.INTERACTION_MESSAGE);
		}
		return message;
	}
	
	public MetaTypedList getFormalGate() {
		if(formalGate == null) {
			formalGate = new MetaTypedList(Gate.class, this, ModelPackage.INTERACTION_FORMALGATE);
		}
		return formalGate;
	}
	
	public MetaTypedList getAction() {
		if(action == null) {
			action = new MetaTypedList(Action.class, this, ModelPackage.INTERACTION_ACTION);
		}
		return action;
	}
	
	public MetaTypedList getOwnedParameter() {
		if(ownedParameter == null) {
			ownedParameter = new MetaTypedList(Parameter.class, this, ModelPackage.BEHAVIOR_OWNEDPARAMETER);
		}
		return ownedParameter;
	}
	
	public MetaTypedList getRedefinedBehavior() {
		if(redefinedBehavior == null) {
			redefinedBehavior = new MetaTypedList(Behavior.class, this, ModelPackage.BEHAVIOR_REDEFINEDBEHAVIOR);
		}
		return redefinedBehavior;
	}
	
	public MetaTypedList getContext() {
		if(context == null) {
			context = new MetaTypedList(BehavioredClassifier.class, this, ModelPackage.BEHAVIOR_CONTEXT);
		}
		return context;
	}
	
	public MetaTypedList getPrecondition() {
		if(precondition == null) {
			precondition = new MetaTypedList(Constraint.class, this, ModelPackage.BEHAVIOR_PRECONDITION);
		}
		return precondition;
	}
	
	public MetaTypedList getPostcondition() {
		if(postcondition == null) {
			postcondition = new MetaTypedList(Constraint.class, this, ModelPackage.BEHAVIOR_POSTCONDITION);
		}
		return postcondition;
	}
	
	public MetaTypedList getOwnedAttribute() {
		if(ownedAttribute == null) {
			ownedAttribute = new MetaTypedList(Property.class, this, ModelPackage.UMLCLASS_OWNEDATTRIBUTE);
		}
		return ownedAttribute;
	}
	
	public MetaTypedList getNestedClassifier() {
		if(nestedClassifier == null) {
			nestedClassifier = new MetaTypedList(Classifier.class, this, ModelPackage.UMLCLASS_NESTEDCLASSIFIER);
		}
		return nestedClassifier;
	}
	
	public MetaTypedList getOwnedOperation() {
		if(ownedOperation == null) {
			ownedOperation = new MetaTypedList(Operation.class, this, ModelPackage.UMLCLASS_OWNEDOPERATION);
		}
		return ownedOperation;
	}
	
	public MetaTypedList getSuperClass() {
		if(superClass == null) {
			superClass = new MetaTypedList(UMLClass.class, this, ModelPackage.UMLCLASS_SUPERCLASS);
		}
		return superClass;
	}
	
	public MetaTypedList getOwnedReception() {
		if(ownedReception == null) {
			ownedReception = new MetaTypedList(Reception.class, this, ModelPackage.UMLCLASS_OWNEDRECEPTION);
		}
		return ownedReception;
	}
	
	public MetaTypedList getAttribute() {
		if(attribute == null) {
			attribute = new MetaTypedList(Property.class, this, ModelPackage.CLASSIFIER_ATTRIBUTE);
		}
		return attribute;
	}
	
	public MetaTypedList getGeneralization() {
		if(generalization == null) {
			generalization = new MetaTypedList(Generalization.class, this, ModelPackage.CLASSIFIER_GENERALIZATION);
		}
		return generalization;
	}
	
	public MetaTypedList getInheritedMember() {
		if(inheritedMember == null) {
			inheritedMember = new MetaTypedList(NamedElement.class, this, ModelPackage.CLASSIFIER_INHERITEDMEMBER);
		}
		return inheritedMember;
	}
	
	public MetaTypedList getGeneral() {
		if(general == null) {
			general = new MetaTypedList(Classifier.class, this, ModelPackage.CLASSIFIER_GENERAL);
		}
		return general;
	}
	
	public MetaTypedList getRedefinedClassifier() {
		if(redefinedClassifier == null) {
			redefinedClassifier = new MetaTypedList(Classifier.class, this, ModelPackage.CLASSIFIER_REDEFINEDCLASSIFIER);
		}
		return redefinedClassifier;
	}
	
	public MetaTypedList getFeature() {
		if(feature == null) {
			feature = new MetaTypedList(Feature.class, this, ModelPackage.CLASSIFIER_FEATURE);
		}
		return feature;
	}
	
	public MetaTypedList getSubstitutingClassifier() {
		if(substitutingClassifier == null) {
			substitutingClassifier = new MetaTypedList(Substitution.class, this, ModelPackage.CLASSIFIER_SUBSTITUTINGCLASSIFIER);
		}
		return substitutingClassifier;
	}
	
	public MetaTypedList getOwnedUseCase() {
		if(ownedUseCase == null) {
			ownedUseCase = new MetaTypedList(UseCase.class, this, ModelPackage.CLASSIFIER_OWNEDUSECASE);
		}
		return ownedUseCase;
	}
	
	public MetaTypedList getCollaborationUse() {
		if(collaborationUse == null) {
			collaborationUse = new MetaTypedList(CollaborationUse.class, this, ModelPackage.CLASSIFIER_COLLABORATIONUSE);
		}
		return collaborationUse;
	}
	
	public MetaTypedList getRepresentation() {
		if(representation == null) {
			representation = new MetaTypedList(CollaborationUse.class, this, ModelPackage.CLASSIFIER_REPRESENTATION);
		}
		return representation;
	}
	
	public MetaTypedList getImportedMember() {
		if(importedMember == null) {
			importedMember = new MetaTypedList(PackageableElement.class, this, ModelPackage.NAMESPACE_IMPORTEDMEMBER);
		}
		return importedMember;
	}
	
	public MetaTypedList getMember() {
		if(member == null) {
			member = new MetaTypedList(NamedElement.class, this, ModelPackage.NAMESPACE_MEMBER);
		}
		return member;
	}
	
	public MetaTypedList getOwnedMember() {
		if(ownedMember == null) {
			ownedMember = new MetaTypedList(NamedElement.class, this, ModelPackage.NAMESPACE_OWNEDMEMBER);
		}
		return ownedMember;
	}
	
	public MetaTypedList getPackageImport() {
		if(packageImport == null) {
			packageImport = new MetaTypedList(PackageImport.class, this, ModelPackage.NAMESPACE_PACKAGEIMPORT);
		}
		return packageImport;
	}
	
	public MetaTypedList getElementImport() {
		if(elementImport == null) {
			elementImport = new MetaTypedList(ElementImport.class, this, ModelPackage.NAMESPACE_ELEMENTIMPORT);
		}
		return elementImport;
	}
	
	public MetaTypedList getOwnedRule() {
		if(ownedRule == null) {
			ownedRule = new MetaTypedList(Constraint.class, this, ModelPackage.NAMESPACE_OWNEDRULE);
		}
		return ownedRule;
	}
	
	public MetaTypedList getRedefinitionContext() {
		if(redefinitionContext == null) {
			redefinitionContext = new MetaTypedList(Classifier.class, this, ModelPackage.REDEFINABLEELEMENT_REDEFINITIONCONTEXT);
		}
		return redefinitionContext;
	}
	
	public MetaTypedList getRedefinedElement() {
		if(redefinedElement == null) {
			redefinedElement = new MetaTypedList(RedefinableElement.class, this, ModelPackage.REDEFINABLEELEMENT_REDEFINEDELEMENT);
		}
		return redefinedElement;
	}
	
	// save & load
	public void serialize(Element root) {
		super.serialize(root);
		// attributes
		
		XMLUtility.xmlInstance.serializeAttribute(root, ModelPackage.BEHAVIOR_ISREENTRANT, isReentrant);
		
		XMLUtility.xmlInstance.serializeAttribute(root, ModelPackage.UMLCLASS_ISACTIVE, isActive);
		
		XMLUtility.xmlInstance.serializeAttribute(root, ModelPackage.CLASSIFIER_ISABSTRACT, isAbstract);
		
		XMLUtility.xmlInstance.serializeAttribute(root, ModelPackage.REDEFINABLEELEMENT_ISLEAF, isLeaf);
		
		// references
		
		XMLUtility.xmlInstance.serializeNodes(root, ModelPackage.INTERACTION_FRAGMENT, fragment);
		
		XMLUtility.xmlInstance.serializeNodes(root, ModelPackage.INTERACTION_LIFELINE, lifeline);
		
		XMLUtility.xmlInstance.serializeNodes(root, ModelPackage.INTERACTION_MESSAGE, message);
		
		XMLUtility.xmlInstance.serializeNodes(root, ModelPackage.INTERACTION_FORMALGATE, formalGate);
		
		XMLUtility.xmlInstance.serializeNodes(root, ModelPackage.INTERACTION_ACTION, action);
		
		XMLUtility.xmlInstance.serializeNodes(root, ModelPackage.BEHAVIOR_OWNEDPARAMETER, ownedParameter);
		
		XMLUtility.xmlInstance.serializeNodesNotContain(root, ModelPackage.BEHAVIOR_REDEFINEDBEHAVIOR, redefinedBehavior);		
		
		XMLUtility.xmlInstance.serializeNodesNotContain(root, ModelPackage.BEHAVIOR_CONTEXT, context);		
		
		XMLUtility.xmlInstance.serializeNodes(root, ModelPackage.BEHAVIOR_PRECONDITION, precondition);
		
		XMLUtility.xmlInstance.serializeNodes(root, ModelPackage.BEHAVIOR_POSTCONDITION, postcondition);
		
		XMLUtility.xmlInstance.serializeNodes(root, ModelPackage.UMLCLASS_OWNEDATTRIBUTE, ownedAttribute);
		
		XMLUtility.xmlInstance.serializeNodes(root, ModelPackage.UMLCLASS_NESTEDCLASSIFIER, nestedClassifier);
		
		XMLUtility.xmlInstance.serializeNodes(root, ModelPackage.UMLCLASS_OWNEDOPERATION, ownedOperation);
		
		XMLUtility.xmlInstance.serializeNodesNotContain(root, ModelPackage.UMLCLASS_SUPERCLASS, superClass);		
		
		XMLUtility.xmlInstance.serializeNodes(root, ModelPackage.UMLCLASS_OWNEDRECEPTION, ownedReception);
		
		XMLUtility.xmlInstance.serializeNodesNotContain(root, ModelPackage.CLASSIFIER_ATTRIBUTE, attribute);		
		
		XMLUtility.xmlInstance.serializeNodes(root, ModelPackage.CLASSIFIER_GENERALIZATION, generalization);
		
		XMLUtility.xmlInstance.serializeNodesNotContain(root, ModelPackage.CLASSIFIER_INHERITEDMEMBER, inheritedMember);		
		
		XMLUtility.xmlInstance.serializeNodesNotContain(root, ModelPackage.CLASSIFIER_GENERAL, general);		
		
		XMLUtility.xmlInstance.serializeNodesNotContain(root, ModelPackage.CLASSIFIER_REDEFINEDCLASSIFIER, redefinedClassifier);		
		
		XMLUtility.xmlInstance.serializeNodesNotContain(root, ModelPackage.CLASSIFIER_FEATURE, feature);		
		
		XMLUtility.xmlInstance.serializeNodes(root, ModelPackage.CLASSIFIER_SUBSTITUTINGCLASSIFIER, substitutingClassifier);
		
		XMLUtility.xmlInstance.serializeNodes(root, ModelPackage.CLASSIFIER_OWNEDUSECASE, ownedUseCase);
		
		XMLUtility.xmlInstance.serializeNodes(root, ModelPackage.CLASSIFIER_COLLABORATIONUSE, collaborationUse);
		
		XMLUtility.xmlInstance.serializeNodesNotContain(root, ModelPackage.CLASSIFIER_REPRESENTATION, representation);		
		
		XMLUtility.xmlInstance.serializeNodesNotContain(root, ModelPackage.NAMESPACE_IMPORTEDMEMBER, importedMember);		
		
		XMLUtility.xmlInstance.serializeNodesNotContain(root, ModelPackage.NAMESPACE_MEMBER, member);		
		
		XMLUtility.xmlInstance.serializeNodes(root, ModelPackage.NAMESPACE_OWNEDMEMBER, ownedMember);
		
		XMLUtility.xmlInstance.serializeNodes(root, ModelPackage.NAMESPACE_PACKAGEIMPORT, packageImport);
		
		XMLUtility.xmlInstance.serializeNodes(root, ModelPackage.NAMESPACE_ELEMENTIMPORT, elementImport);
		
		XMLUtility.xmlInstance.serializeNodes(root, ModelPackage.NAMESPACE_OWNEDRULE, ownedRule);
		
		XMLUtility.xmlInstance.serializeNodesNotContain(root, ModelPackage.REDEFINABLEELEMENT_REDEFINITIONCONTEXT, redefinitionContext);		
		
		XMLUtility.xmlInstance.serializeNodesNotContain(root, ModelPackage.REDEFINABLEELEMENT_REDEFINEDELEMENT, redefinedElement);		
		
	}
	
	public void deSerialize(Element root) {
		super.deSerialize(root);
		// attributes
		
		isReentrant = XMLUtility.xmlInstance.deSerializeBoolean(root, ModelPackage.BEHAVIOR_ISREENTRANT);
		
		isActive = XMLUtility.xmlInstance.deSerializeBoolean(root, ModelPackage.UMLCLASS_ISACTIVE);
		
		isAbstract = XMLUtility.xmlInstance.deSerializeBoolean(root, ModelPackage.CLASSIFIER_ISABSTRACT);
		
		isLeaf = XMLUtility.xmlInstance.deSerializeBoolean(root, ModelPackage.REDEFINABLEELEMENT_ISLEAF);
		
		// references
		
		this.getFragment().addAll(XMLUtility.xmlInstance.deSerializeNodes(root, ModelPackage.INTERACTION_FRAGMENT));
		
		this.getLifeline().addAll(XMLUtility.xmlInstance.deSerializeNodes(root, ModelPackage.INTERACTION_LIFELINE));
		
		this.getMessage().addAll(XMLUtility.xmlInstance.deSerializeNodes(root, ModelPackage.INTERACTION_MESSAGE));
		
		this.getFormalGate().addAll(XMLUtility.xmlInstance.deSerializeNodes(root, ModelPackage.INTERACTION_FORMALGATE));
		
		this.getAction().addAll(XMLUtility.xmlInstance.deSerializeNodes(root, ModelPackage.INTERACTION_ACTION));
		
		this.getOwnedParameter().addAll(XMLUtility.xmlInstance.deSerializeNodes(root, ModelPackage.BEHAVIOR_OWNEDPARAMETER));
		
		this.getRedefinedBehavior().addAll(XMLUtility.xmlInstance.deSerializeNodesNotContain(root, ModelPackage.BEHAVIOR_REDEFINEDBEHAVIOR, this));
		
		this.getContext().addAll(XMLUtility.xmlInstance.deSerializeNodesNotContain(root, ModelPackage.BEHAVIOR_CONTEXT, this));
		
		this.getPrecondition().addAll(XMLUtility.xmlInstance.deSerializeNodes(root, ModelPackage.BEHAVIOR_PRECONDITION));
		
		this.getPostcondition().addAll(XMLUtility.xmlInstance.deSerializeNodes(root, ModelPackage.BEHAVIOR_POSTCONDITION));
		
		this.getOwnedAttribute().addAll(XMLUtility.xmlInstance.deSerializeNodes(root, ModelPackage.UMLCLASS_OWNEDATTRIBUTE));
		
		this.getNestedClassifier().addAll(XMLUtility.xmlInstance.deSerializeNodes(root, ModelPackage.UMLCLASS_NESTEDCLASSIFIER));
		
		this.getOwnedOperation().addAll(XMLUtility.xmlInstance.deSerializeNodes(root, ModelPackage.UMLCLASS_OWNEDOPERATION));
		
		this.getSuperClass().addAll(XMLUtility.xmlInstance.deSerializeNodesNotContain(root, ModelPackage.UMLCLASS_SUPERCLASS, this));
		
		this.getOwnedReception().addAll(XMLUtility.xmlInstance.deSerializeNodes(root, ModelPackage.UMLCLASS_OWNEDRECEPTION));
		
		this.getAttribute().addAll(XMLUtility.xmlInstance.deSerializeNodesNotContain(root, ModelPackage.CLASSIFIER_ATTRIBUTE, this));
		
		this.getGeneralization().addAll(XMLUtility.xmlInstance.deSerializeNodes(root, ModelPackage.CLASSIFIER_GENERALIZATION));
		
		this.getInheritedMember().addAll(XMLUtility.xmlInstance.deSerializeNodesNotContain(root, ModelPackage.CLASSIFIER_INHERITEDMEMBER, this));
		
		this.getGeneral().addAll(XMLUtility.xmlInstance.deSerializeNodesNotContain(root, ModelPackage.CLASSIFIER_GENERAL, this));
		
		this.getRedefinedClassifier().addAll(XMLUtility.xmlInstance.deSerializeNodesNotContain(root, ModelPackage.CLASSIFIER_REDEFINEDCLASSIFIER, this));
		
		this.getFeature().addAll(XMLUtility.xmlInstance.deSerializeNodesNotContain(root, ModelPackage.CLASSIFIER_FEATURE, this));
		
		this.getSubstitutingClassifier().addAll(XMLUtility.xmlInstance.deSerializeNodes(root, ModelPackage.CLASSIFIER_SUBSTITUTINGCLASSIFIER));
		
		this.getOwnedUseCase().addAll(XMLUtility.xmlInstance.deSerializeNodes(root, ModelPackage.CLASSIFIER_OWNEDUSECASE));
		
		this.getCollaborationUse().addAll(XMLUtility.xmlInstance.deSerializeNodes(root, ModelPackage.CLASSIFIER_COLLABORATIONUSE));
		
		this.getRepresentation().addAll(XMLUtility.xmlInstance.deSerializeNodesNotContain(root, ModelPackage.CLASSIFIER_REPRESENTATION, this));
		
		this.getImportedMember().addAll(XMLUtility.xmlInstance.deSerializeNodesNotContain(root, ModelPackage.NAMESPACE_IMPORTEDMEMBER, this));
		
		this.getMember().addAll(XMLUtility.xmlInstance.deSerializeNodesNotContain(root, ModelPackage.NAMESPACE_MEMBER, this));
		
		this.getOwnedMember().addAll(XMLUtility.xmlInstance.deSerializeNodes(root, ModelPackage.NAMESPACE_OWNEDMEMBER));
		
		this.getPackageImport().addAll(XMLUtility.xmlInstance.deSerializeNodes(root, ModelPackage.NAMESPACE_PACKAGEIMPORT));
		
		this.getElementImport().addAll(XMLUtility.xmlInstance.deSerializeNodes(root, ModelPackage.NAMESPACE_ELEMENTIMPORT));
		
		this.getOwnedRule().addAll(XMLUtility.xmlInstance.deSerializeNodes(root, ModelPackage.NAMESPACE_OWNEDRULE));
		
		this.getRedefinitionContext().addAll(XMLUtility.xmlInstance.deSerializeNodesNotContain(root, ModelPackage.REDEFINABLEELEMENT_REDEFINITIONCONTEXT, this));
		
		this.getRedefinedElement().addAll(XMLUtility.xmlInstance.deSerializeNodesNotContain(root, ModelPackage.REDEFINABLEELEMENT_REDEFINEDELEMENT, this));
		
	}
	
	public void dynamicSet(String featureID, Object value) {
		if(featureID == null || "".equals(featureID)) {
			return;
		}
		// attributes
		
		// references
		
		else if(ModelPackage.BEHAVIOR_REDEFINEDBEHAVIOR.equals(featureID)) {
			getRedefinedBehavior().add(value);
		}
		
		else if(ModelPackage.BEHAVIOR_CONTEXT.equals(featureID)) {
			getContext().add(value);
		}
		
		else if(ModelPackage.UMLCLASS_SUPERCLASS.equals(featureID)) {
			getSuperClass().add(value);
		}
		
		else if(ModelPackage.CLASSIFIER_ATTRIBUTE.equals(featureID)) {
			getAttribute().add(value);
		}
		
		else if(ModelPackage.CLASSIFIER_INHERITEDMEMBER.equals(featureID)) {
			getInheritedMember().add(value);
		}
		
		else if(ModelPackage.CLASSIFIER_GENERAL.equals(featureID)) {
			getGeneral().add(value);
		}
		
		else if(ModelPackage.CLASSIFIER_REDEFINEDCLASSIFIER.equals(featureID)) {
			getRedefinedClassifier().add(value);
		}
		
		else if(ModelPackage.CLASSIFIER_FEATURE.equals(featureID)) {
			getFeature().add(value);
		}
		
		else if(ModelPackage.CLASSIFIER_REPRESENTATION.equals(featureID)) {
			getRepresentation().add(value);
		}
		
		else if(ModelPackage.NAMESPACE_IMPORTEDMEMBER.equals(featureID)) {
			getImportedMember().add(value);
		}
		
		else if(ModelPackage.NAMESPACE_MEMBER.equals(featureID)) {
			getMember().add(value);
		}
		
		else if(ModelPackage.REDEFINABLEELEMENT_REDEFINITIONCONTEXT.equals(featureID)) {
			getRedefinitionContext().add(value);
		}
		
		else if(ModelPackage.REDEFINABLEELEMENT_REDEFINEDELEMENT.equals(featureID)) {
			getRedefinedElement().add(value);
		}
		
		else
			super.dynamicSet(featureID, value);
	}
}
 
 
 
 
 